home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / ear / mui23dev.lha / MUI / Developer / Oberon / txt / MuiBasics.mod < prev    next >
Text File  |  1994-12-21  |  71KB  |  1,872 lines
  1. (*------------------------------------------
  2.   :Module.      MuiBasics.mod
  3.   :Author.      Albert Weinert  [awn]
  4.   :Address.     Adamsstr. 83; 51063 Köln, Germany
  5.   :EMail.       a.weinert@darkness.gun.de
  6.   :Phone.       +49-221-613100
  7.   :Revision.    R.22
  8.   :Date.        19-Aug-1994
  9.   :Copyright.   FreeWare.
  10.   :Language.    Oberon-2
  11.   :Translator.  AmigaOberon V3.11
  12.   :Contents.    Die Makros die in "mui.h" definiert, waren als Prozeduren für Oberon
  13.   :Imports.     <Importiertes, Name/ShortCut des Autors>
  14.   :Remarks.     Bei VCenter, HCenter, Popup ist es etwas anders.
  15.   :Bugs.        <Bekannte Fehler>
  16.   :Usage.       <Angaben zur Anwendung>
  17.   :History.     .1     [awn] 22-Aug-1993 : Die Prozeduren die in Mui.mod waren nun
  18.   :History.            entfernt und ein seperates Modul daraus gemacht, so das
  19.   :History.            man nicht darauf angewiesen dies in seinem Interfaces zu haben.
  20.   :History.     .2     [awn] 24-Aug-1993 : Kräftig aufgeräumt um den erzeugten
  21.   :History.            Maschinencode so kurz wie möglich zu halten.
  22.   :History.     .3     [awn] 24-Aug-1993 : PopupEnd() so erweitert das nun ein
  23.   :History.            Objekt mit angeben werden kann, dies ist dafür gedacht wenn
  24.   :History.            man das Popup zu einem anderen Objekt anordnet (z.B String )
  25.   :History.     .4     [awn] 24-Aug-1993 : Im Zuge der Popup Änderung wurde eine
  26.   :History.            eigene Speziell auf Mui abgestimmte Hook Parameter übergabe
  27.   :History.            erstellt (Allerdings OS Konform eingebettet). Der Parameter
  28.   :History.            Deklaration der Hook-Prozedur muss nun so aussehen wie der
  29.   :History.            Typ `HookDef'.
  30.   :History.     .5     [awn] 25-Aug-1993 : Tipfehler bei TagItem2() und TagItem3()
  31.   :History.            entfernt.
  32.   :History.     .6     [awn] 25-Aug-1993 : Die Groups und Frames wieder mit der
  33.   :History.            Möglichkeit versehen dort TagListen zu übergeben.
  34.   :History.     .7     [awn] 30-Aug-1993 : PageGroup() hizugefügt.
  35.   :History.     .8     [awn] 14-Sep-1993 : Fehler bei Strings() dort wurde in der
  36.   :History.            Deklaration 2 mal A1 benutzt.
  37.   :History.     .9     [awn] 03-Oct-1993 : Eine einfache Plausibiltätsprüfung eingebaut.
  38.   :History.            Für jede #?Object() Prozedur gibt es nun ein End#?() Prozedure,
  39.   :History.            wenn der Objekt Typ nicht übereinstimmt wird ein NIL zurückgeben.
  40.   :History.            Dies ist dafür um während der Programmentwicklung Abstürze zu
  41.   :History.            umgehen, wenn das Programm einmal steht sind diese nicht mehr
  42.   :History.            notwendig, aber brauchen nicht entfernt zu werden.
  43.   :History.     .10    [awn] 30-Oct-1993 : An MUI 1.4 angepasst, die neuen Objekte
  44.   :History.            hinzugefügt (Coloradjust, Colorfield, Palette, Virtgroup, Scrollgroup
  45.   :History.            und Scrmodelist), die Group Prozeduren gibt es nun auch für Virtgroups
  46.   :History.            z.B. HGroupV(). Sonstige neue Prozeduren, KeyRadio(), Slider(), KeySlider(),
  47.   :History.            LLabelX() und KeyLLabelX().
  48.   :History.     .11    [awn] 31-Jan-1994 : Angepasst an MUI 1.5, Fehler bei SliderObject()
  49.   :History.            entfernt (Rief RadioObject auf). Es gibt nun für *jede* Objekt ein
  50.   :History.            passendes. Bei Popupend() wird nun auch das Background Image gesetzt.
  51.   :History.            [Report: Peter Elzner]
  52.   :History.     .12    [awn] 02-Feb-1994 : INewObject() und IEnd() aufgenommen, der Aufruf
  53.   :History.            von INewObject() ist wie der von Intuition.NewObject() nur ohne
  54.   :History.            Rückgabeparamter. INewObject() muss *anstatt* Intuition.NewObject()
  55.   :History.            aufgerufen werden wenn die Objekte direkt mit ins Layout sollen.
  56.   :History.            INewObject() *muss* ein IEnd() bzw. iEnd() folgen. siehe Class1.mod
  57.   :History.     .13    [awn] 05-Feb-1994 : VSlider() und KeyVSlider() aufgenommen.
  58.   :History.     .14    [awn] 17-Feb-1994 : Bei Checkmark(); KeyCheckmark(), String() und
  59.   :History.            KeyString() ist es nun auch möglich Tags zu übergeben.
  60.   :History.            KeyVSlider() ist nun wirklich ein VSlider. PopButton() hinzugefügt.
  61.   :History.            Der Register.mui Support ist nun auch drin.
  62.   :History.            HBar() und VBar() erstellt, erzeugen die entsprechenden Bars.
  63.   :History.     .15    [awn] 22-Feb-1994 : Integer() und KeyInteger() für Integer-
  64.   :History.            Objekte hinzugefügt.
  65.   :History.     .16    [awn] 27-Feb-1994 : Bei etlichen Prozeduren habe ich vergessen
  66.   :History.            die Register zu retten, so das CheckMark() und KeyCheckMark()
  67.   :History.            nicht zufriedenstellend funktionierte [Report: Volker Rudolph]
  68.   :History.     .17    [awn] 05-Apr-1994 : Bei CheckMark() funktioniert die Initiali-
  69.   :History.            sierung jetzt. Scrollbar(), KeyScrollBar(), VScrollBar() usw.
  70.   :History.            Prozeduren für die entsprechenden Objekte erstellt.
  71.   :History.     .18    [awn] 15-May-1994 : Bei CheckMarkA() die Parameter etwas
  72.   :History.            geändert, so das dieses nun auch richtig funktioniert.
  73.   :History.     .19    [awn] 02-Jul-1994 : ClassTree overview updated, updated
  74.   :History.            to MUI 2.1, major code cleanup (now, produces shorter code).
  75.   :History.            In lack of time, i didn't optimize the label prozedures.
  76.   :History.            The behavior fo the End#?() procedures changes, if the wrong
  77.   :History.            object type, the programm terminates with an RC=100, also
  78.   :History.            now there added end#?() proecedures, so that you don't must
  79.   :History.            check the result if you want only have a little typeguard.
  80.   :History.     .20    [Volker Rudolph] 20-Jul 1994 : Fixed another bug in functions
  81.   :History.            with CHAR, BOOLEAN or SHORTINT variables as register arguments.
  82.   :History.            Removed (* SaveRegs+ *) comments.
  83.   :History.     .21    [awn] 07-Aug-1994 : Bug in KeyButton() taglist parameter removed
  84.   :History.            (Report by Frank Düring). End#?() Prozedures allready compares
  85.   :History.            with Mui.cApplication.
  86.   :History.     .22    [awn] 19-Aug-1994 : Removed the Hook binded objects, is was not
  87.   :History.            Removed the PopupArgs() struct, added the procedzre PopupObject()
  88.   :History.            (to avoid SYSTEM.VAL() to get the Popupobject from the args parameter.
  89.   :History.            Now uses the Hooks from Utility.mod
  90.  
  91.  
  92. --------------------------------------------*)
  93. MODULE MuiBasics;
  94.  
  95. IMPORT e * := Exec,
  96.        I * := Intuition,
  97.        m * := Mui,
  98.        u * := Utility,
  99.        y   :=SYSTEM;
  100.  
  101. CONST   ArrayAdd = 24;
  102.  
  103. TYPE
  104.   TagArray * = UNTRACED POINTER TO ARRAY OF u.TagItem;
  105.   Class    * = UNTRACED POINTER TO ClassDesc;
  106.   Args     * = UNTRACED POINTER TO ArgsDesc;
  107.   Hook     * = u.HookPtr;
  108.  
  109.   ClassDesc = STRUCT( n : e.Node );
  110.                 name   : ARRAY 32 OF CHAR;
  111.                 iclass : I.IClassPtr;
  112.                 tags   : TagArray;
  113.                 tagnum : LONGINT;
  114.                 tagdata : BOOLEAN;
  115.               END;
  116.  
  117.   ArgsDesc * = STRUCT END;
  118.  
  119.   HookDef * = PROCEDURE ( hook : Hook; object : m.Object; args : Args ):LONGINT;
  120.  
  121.  
  122. (* Hook-Example.
  123.  *
  124.  *  TYPE  PopWindowArgs = STRUCT( d : MuiBasics.ArgsDesc );
  125.  *                          window : m.Object;
  126.  *                        END;
  127.  *
  128.  *  VAR myHook : MuiBasics.Hook;
  129.  *      button : m.Object;
  130.  *      window : m.Object;
  131.  *
  132.  *  PROCEDURE PopWindow( hook : Hook; object : m.Object; args : Args ) : LONGINT;
  133.  *    BEGIN
  134.  *      IF args # NIL THEN
  135.  *        IF args(PopWindowArgs).window # NIL THEN
  136.  *          m.DoMethod( args(PopWindowArgs).window, m.mWindowToFront );
  137.  *        END;
  138.  *      END;
  139.  *      RETURN 0;
  140.  *    END PopWindow;
  141.  *
  142.  *  BEGIN
  143.  *    [... create Application Windows ...]
  144.  *
  145.  *    myHook := MuiBasics.MakeHook( PopWindow );
  146.  *    IF myHook # NIL THEN
  147.  *      m.DoMethod( button, m.mNotify, m.aPressed, e.false,
  148.  *                    button, 3, m.mCallHook, myHook, window );
  149.  *    END;
  150.  *    [... Do the other magic ...]
  151.  *
  152.  * Note: Typed on the fly, no warranty is given that this piece of code reallay work.
  153.  *)
  154.  
  155. VAR no * : e.List;
  156.  
  157.   PROCEDURE MakeHook* ( entry: HookDef ):Hook;
  158.   (*------------------------------------------
  159.     :Input.     entry : Prozedure die gestartet werden soll, wenn der Hook
  160.     :Input.             aufgerufen wird.
  161.     :Output.    Hook der direkt einsatzfähig ist (oder NIL, falls es nicht
  162.     :Output.    geklappt haben sollte).
  163.     :Semantic.  Erstellt einen Hook und bindet die Prozedure ein.
  164.     :Note.
  165.     :Update.    24-Aug-1993 [awn] - erstellt.
  166.     :Update.    19-Aug-1994 [awn] - Now use SYSTEM.ALLOCATE() instead of NEW()
  167.     :Update.                Now use the Hooks things from Utility.mod
  168.     :Update.                also the hook binded object is removed
  169.   --------------------------------------------*)
  170.     VAR hook : Hook;
  171.   BEGIN
  172.     y.ALLOCATE( hook );
  173.     IF hook # NIL THEN
  174.       u.InitHook( y.VAL( u.HookPtr, hook ), y.VAL( u.HookFunc, entry ) );
  175.     END;
  176.     RETURN hook;
  177.   END MakeHook;
  178.  
  179.   PROCEDURE Init();
  180.     BEGIN
  181.       no.head := y.ADR( no.tail );
  182.       no.tail := NIL;
  183.       no.tailPred := y.ADR( no.head );
  184.     END Init;
  185.  
  186.   PROCEDURE NewClass*();
  187.     VAR cl : Class;
  188.     BEGIN
  189.       NEW( cl );
  190.  
  191.       (* $IF GarbageCollector *)
  192.  
  193.       e.AddTail( no, cl );
  194.  
  195.       (* $ELSE *)
  196.  
  197.       IF cl # NIL THEN
  198.         e.AddTail( no, y.VAL( e.CommonNodePtr, cl ) );
  199.         cl.tagdata := FALSE;
  200.       END;
  201.  
  202.       (* $END *)
  203.     END NewClass;
  204.  
  205.   PROCEDURE CheckAndExpandTags( cl : Class;  n : LONGINT);
  206.     VAR newtags : TagArray;
  207.         ShouldLen, MaxLen, i : LONGINT;
  208.  
  209.     BEGIN
  210.       IF n = 0 THEN RETURN END;
  211.       IF cl.tags # NIL THEN
  212.         ShouldLen := cl.tagnum + n;
  213.         MaxLen := LEN( cl.tags^ )-1;
  214.         IF ShouldLen >= MaxLen THEN
  215.           INC( ShouldLen, ArrayAdd );
  216.           y.ALLOCATE( newtags, ShouldLen );
  217.           FOR i := 0 TO cl.tagnum-1 DO
  218.             newtags[i] := cl.tags[i];
  219.           END;
  220.  
  221.           (* $IF GarbageCollector *)
  222.  
  223.             cl.tags := newtags;
  224.  
  225.           (* $ELSE *)
  226.  
  227.             DISPOSE( cl.tags );
  228.             cl.tags := newtags;
  229.  
  230.           (* $END *)
  231.         END;
  232.       ELSE
  233.         ShouldLen := ArrayAdd + n ;
  234.         NEW( cl.tags, ShouldLen );
  235.         cl.tagnum := 0;
  236.       END;
  237.     END CheckAndExpandTags;
  238.  
  239.   PROCEDURE clTag ( cl : Class;  tag : e.APTR );
  240.     BEGIN
  241.       CheckAndExpandTags( cl, 1 );
  242.       IF cl.tags # NIL THEN
  243.         IF cl.tagdata THEN
  244.           cl.tags[cl.tagnum].data := tag;
  245.           cl.tagdata := FALSE;
  246.           INC( cl.tagnum );
  247.         ELSE
  248.           cl.tags[cl.tagnum].tag := tag;
  249.           cl.tagdata := TRUE;
  250.         END;
  251.       END;
  252.     END clTag;
  253.  
  254.   PROCEDURE clTagItem ( cl : Class;  tag, data : e.APTR );
  255.     BEGIN
  256.       CheckAndExpandTags( cl, 1 );
  257.       IF cl.tags # NIL THEN
  258.         cl.tags[cl.tagnum].data := data;
  259.         cl.tags[cl.tagnum].tag := tag;
  260.         INC( cl.tagnum );
  261.       END;
  262.     END clTagItem;
  263.  
  264.   PROCEDURE countTag( tags{9} : u.TagListPtr) : LONGINT;
  265.     VAR i, j : LONGINT;
  266.     BEGIN
  267.       i := 0; j := 0;
  268.       WHILE (tags # NIL) & (tags[j].tag # u.end) DO
  269.         IF tags[j].tag = u.more THEN
  270.           tags := tags[j].data;
  271.           j := 0;
  272.         ELSE
  273.           INC(i); INC(j);
  274.         END;
  275.       END;
  276.       RETURN i;
  277.     END countTag;
  278.  
  279.   PROCEDURE clTagsA*( cl{8} : Class;  tags{9} : u.TagListPtr );
  280.     VAR  i : LONGINT;
  281.  
  282.     BEGIN
  283.       IF tags = NIL THEN RETURN END;
  284.       CheckAndExpandTags( cl, countTag( tags ) );
  285.       i:=0;
  286.       IF cl.tags # NIL THEN
  287.         WHILE (tags#NIL) & (tags[i].tag # u.end) DO
  288.           IF tags[i].tag = u.more THEN
  289.             tags := tags[i].data;
  290.             i := 0;
  291.           ELSE
  292.             cl.tags[cl.tagnum] := tags[i];
  293.             INC(cl.tagnum); INC(i);
  294.           END;
  295.         END;
  296.       END;
  297.     END clTagsA;
  298.  
  299.   PROCEDURE clTags{"MuiBasics.clTagsA"} ( cl{8} : Class;  tags{9}.. : u.Tag );
  300.  
  301.   PROCEDURE TagsA*( tags{9} : u.TagListPtr );
  302.     BEGIN
  303.       IF no.tailPred # y.ADR( no.head ) THEN;
  304.         clTagsA( y.VAL( Class, no.tailPred ), tags );
  305.       END;
  306.     END TagsA;
  307.  
  308.   PROCEDURE Tags*{"MuiBasics.TagsA"} ( tags{9}.. : u.Tag );
  309.  
  310.   PROCEDURE Tag*( tag : e.APTR );
  311.     BEGIN
  312.       IF no.tailPred # y.ADR( no.head )  THEN
  313.         clTag( y.VAL( Class, no.tailPred ), tag );
  314.       END;
  315.     END Tag;
  316.  
  317.   PROCEDURE TagItem*( tag, data : e.APTR );
  318.     BEGIN
  319.       IF no.tailPred # y.ADR( no.head )  THEN
  320.         clTagItem( y.VAL( Class, no.tailPred ), tag, data );
  321.       END;
  322.     END TagItem;
  323.  
  324.   PROCEDURE TagItem2*( tag1, data1, tag2, data2 : e.APTR );
  325.     BEGIN
  326.       IF no.tailPred # y.ADR( no.head )  THEN
  327.         clTagItem( y.VAL( Class, no.tailPred ), tag1, data1 );
  328.         clTagItem( y.VAL( Class, no.tailPred ), tag2, data2 );
  329.       END;
  330.     END TagItem2;
  331.  
  332.   PROCEDURE TagItem3*( tag1, data1, tag2, data2, tag3, data3 : e.APTR );
  333.     BEGIN
  334.       IF no.tailPred # y.ADR( no.head )  THEN
  335.         clTagItem( y.VAL( Class, no.tailPred ), tag1, data1 );
  336.         clTagItem( y.VAL( Class, no.tailPred ), tag2, data2 );
  337.         clTagItem( y.VAL( Class, no.tailPred ), tag3, data3 );
  338.       END;
  339.     END TagItem3;
  340.  
  341.   PROCEDURE DEnd(mui : BOOLEAN):m.Object;
  342.     VAR cl : e.NodePtr;
  343.         ret : e.APTR;
  344.  
  345.     BEGIN
  346.       ret := NIL;
  347.       cl := no.tailPred;
  348.       WITH cl : Class DO
  349.  
  350.         IF cl.tags # NIL THEN
  351.           cl.tags[cl.tagnum].tag:=u.end;
  352.           IF mui THEN
  353.             ret := m.NewObject( cl.name, u.more, y.ADR(cl.tags^) );
  354.           ELSE
  355.             IF cl.iclass # NIL THEN
  356.               ret := I.NewObject( cl.iclass, NIL, u.more, y.ADR(cl.tags^) );
  357.             ELSE
  358.               ret := I.NewObject( NIL, cl.name, u.more, y.ADR(cl.tags^) );
  359.             END;
  360.           END;
  361.         ELSE
  362.           IF mui THEN
  363.             ret := m.NewObject( cl.name );
  364.           ELSE
  365.             IF cl.iclass # NIL THEN
  366.               ret := I.NewObject( cl.iclass, NIL );
  367.             ELSE
  368.               ret := I.NewObject( NIL, cl.name );
  369.             END;
  370.           END;
  371.         END;
  372.  
  373.         e.Remove( cl );
  374.  
  375.         (* $IFNOT GarbageCollector *)
  376.  
  377.           DISPOSE( cl.tags );
  378.           DISPOSE( cl );
  379.  
  380.         (* $END *)
  381.  
  382.  
  383.         IF no.tailPred # y.ADR( no.head ) THEN
  384.           clTag( y.VAL( Class, no.tailPred ), ret );
  385.         END;
  386.  
  387.       END;
  388.       RETURN ret;
  389.     END DEnd;
  390.  
  391.   PROCEDURE End*():m.Object;
  392.     BEGIN
  393.       RETURN DEnd( TRUE );
  394.     END End;
  395.  
  396.   PROCEDURE end*();
  397.     BEGIN
  398.       y.SETREG( 0, End() );
  399.     END end;
  400.  
  401.   PROCEDURE IEnd*():m.Object;
  402.     BEGIN
  403.       RETURN DEnd( FALSE );
  404.     END IEnd;
  405.  
  406.   PROCEDURE iEnd*();
  407.     BEGIN
  408.       y.SETREG( 0, IEnd() );
  409.     END iEnd;
  410.  
  411.   PROCEDURE EndObject( objname : ARRAY OF CHAR ):m.Object;
  412.     BEGIN
  413.       IF objname # no.tailPred(Class).name THEN HALT(100) END;
  414.       RETURN End();
  415.     END EndObject;
  416.  
  417.   PROCEDURE endFamily*{"MuiBasics.EndFamily"};
  418.   PROCEDURE EndFamily*():m.Object; BEGIN RETURN EndObject( m.cFamily ) END EndFamily;
  419.   PROCEDURE endMenustrip*{"MuiBasics.EndMenustrip"};
  420.   PROCEDURE EndMenustrip*():m.Object; BEGIN RETURN EndObject( m.cMenustrip ) END EndMenustrip;
  421.   PROCEDURE endMenu*{"MuiBasics.EndMenu"};
  422.   PROCEDURE EndMenu*():m.Object; BEGIN RETURN EndObject( m.cMenu ) END EndMenu;
  423.   PROCEDURE endMenuT*{"MuiBasics.EndMenuT"};
  424.   PROCEDURE EndMenuT*():m.Object; BEGIN RETURN EndObject( m.cMenu ) END EndMenuT;
  425.   PROCEDURE endMenuitem*{"MuiBasics.EndMenuitem"};
  426.   PROCEDURE EndMenuitem*():m.Object; BEGIN RETURN EndObject( m.cMenuitem ) END EndMenuitem;
  427.   PROCEDURE endWindow*{"MuiBasics.EndWindow"};
  428.   PROCEDURE EndWindow*():m.Object; BEGIN RETURN EndObject( m.cWindow ) END EndWindow;
  429.   PROCEDURE endImage*{"MuiBasics.EndImage"};
  430.   PROCEDURE EndImage*():m.Object; BEGIN RETURN EndObject( m.cImage ) END EndImage;
  431.   PROCEDURE endBitmap*{"MuiBasics.EndBitmap"};
  432.   PROCEDURE EndBitmap*():m.Object; BEGIN RETURN EndObject( m.cBitmap ) END EndBitmap;
  433.   PROCEDURE endBodychunk*{"MuiBasics.EndBodychunk"};
  434.   PROCEDURE EndBodychunk*():m.Object; BEGIN RETURN EndObject( m.cImage ) END EndBodychunk;
  435.   PROCEDURE endNotify*{"MuiBasics.EndNotify"};
  436.   PROCEDURE EndNotify*():m.Object; BEGIN RETURN EndObject( m.cNotify ) END EndNotify;
  437.   PROCEDURE endApplication*{"MuiBasics.EndApplication"};
  438.   PROCEDURE EndApplication*():m.Object; BEGIN RETURN EndObject( m.cApplication ) END EndApplication;
  439.   PROCEDURE endText*{"MuiBasics.EndText"};
  440.   PROCEDURE EndText*():m.Object; BEGIN RETURN EndObject( m.cText ) END EndText;
  441.   PROCEDURE endRectangle*{"MuiBasics.EndRectangle"};
  442.   PROCEDURE EndRectangle*():m.Object; BEGIN RETURN EndObject( m.cRectangle ) END EndRectangle;
  443.   PROCEDURE endList*{"MuiBasics.EndList"};
  444.   PROCEDURE EndList*():m.Object; BEGIN RETURN EndObject( m.cList ) END EndList;
  445.   PROCEDURE endProp*{"MuiBasics.EndProp"};
  446.   PROCEDURE EndProp*():m.Object; BEGIN RETURN EndObject( m.cProp ) END EndProp;
  447.   PROCEDURE endString*{"MuiBasics.EndString"};
  448.   PROCEDURE EndString*():m.Object; BEGIN RETURN EndObject( m.cString ) END EndString;
  449.   PROCEDURE endScrollbar*{"MuiBasics.EndScrollbar"};
  450.   PROCEDURE EndScrollbar*():m.Object; BEGIN RETURN EndObject( m.cScrollbar ) END EndScrollbar;
  451.   PROCEDURE endListview*{"MuiBasics.EndListview"};
  452.   PROCEDURE EndListview*():m.Object; BEGIN RETURN EndObject( m.cListview ) END EndListview;
  453.   PROCEDURE endRadio*{"MuiBasics.EndRadio"};
  454.   PROCEDURE EndRadio*():m.Object; BEGIN RETURN EndObject( m.cRadio ) END EndRadio;
  455.   PROCEDURE endVolumelist*{"MuiBasics.EndVolumelist"};
  456.   PROCEDURE EndVolumelist*():m.Object; BEGIN RETURN EndObject( m.cVolumelist ) END EndVolumelist;
  457.   PROCEDURE endFloattext*{"MuiBasics.EndFloattext"};
  458.   PROCEDURE EndFloattext*():m.Object; BEGIN RETURN EndObject( m.cFloattext ) END EndFloattext;
  459.   PROCEDURE endDirlist*{"MuiBasics.EndDirlist"};
  460.   PROCEDURE EndDirlist*():m.Object; BEGIN RETURN EndObject( m.cDirlist ) END EndDirlist;
  461.   PROCEDURE endSlider*{"MuiBasics.EndSlider"};
  462.   PROCEDURE EndSlider*():m.Object; BEGIN RETURN EndObject( m.cSlider ) END EndSlider;
  463.   PROCEDURE endCycle*{"MuiBasics.EndCycle"};
  464.   PROCEDURE EndCycle*():m.Object; BEGIN RETURN EndObject( m.cCycle ) END EndCycle;
  465.   PROCEDURE endGauge*{"MuiBasics.EndGauge"};
  466.   PROCEDURE EndGauge*():m.Object; BEGIN RETURN EndObject( m.cGauge ) END EndGauge;
  467.   PROCEDURE endScale*{"MuiBasics.EndScale"};
  468.   PROCEDURE EndScale*():m.Object; BEGIN RETURN EndObject( m.cScale ) END EndScale;
  469.   PROCEDURE endBoopsi*{"MuiBasics.EndBoopsi"};
  470.   PROCEDURE EndBoopsi*():m.Object; BEGIN RETURN EndObject( m.cBoopsi ) END EndBoopsi;
  471.   PROCEDURE endColorfield*{"MuiBasics.EndColorfield"};
  472.   PROCEDURE EndColorfield*():m.Object; BEGIN RETURN EndObject( m.cColorfield ) END EndColorfield;
  473.   PROCEDURE endColorpanel*{"MuiBasics.EndColorpanel"};
  474.   PROCEDURE EndColorpanel*():m.Object; BEGIN RETURN EndObject( m.cColorpanel ) END EndColorpanel;
  475.   PROCEDURE endColoradjust*{"MuiBasics.EndColoradjust"};
  476.   PROCEDURE EndColoradjust*():m.Object; BEGIN RETURN EndObject( m.cColoradjust ) END EndColoradjust;
  477.   PROCEDURE endPalette*{"MuiBasics.EndPalette"};
  478.   PROCEDURE EndPalette*():m.Object; BEGIN RETURN EndObject( m.cPalette ) END EndPalette;
  479.   PROCEDURE endGroup*{"MuiBasics.EndGroup"};
  480.   PROCEDURE EndGroup*():m.Object; BEGIN RETURN EndObject( m.cGroup ) END EndGroup;
  481.   PROCEDURE endRegister*{"MuiBasics.EndRegister"};
  482.   PROCEDURE EndRegister*():m.Object; BEGIN RETURN EndObject( m.cRegister ) END EndRegister;
  483.   PROCEDURE endVirtgroup*{"MuiBasics.EndVirtgroup"};
  484.   PROCEDURE EndVirtgroup*():m.Object; BEGIN RETURN EndObject( m.cVirtgroup ) END EndVirtgroup;
  485.   PROCEDURE endScrollgroup*{"MuiBasics.EndScrollgroup"};
  486.   PROCEDURE EndScrollgroup*():m.Object; BEGIN RETURN EndObject( m.cScrollgroup ) END EndScrollgroup;
  487.   PROCEDURE endPopstring*{"MuiBasics.EndPopstring"};
  488.   PROCEDURE EndPopstring*():m.Object; BEGIN RETURN EndObject( m.cPopstring ) END EndPopstring;
  489.   PROCEDURE endPopobject*{"MuiBasics.EndPopobject"};
  490.   PROCEDURE EndPopobject*():m.Object; BEGIN RETURN EndObject( m.cPopobject ) END EndPopobject;
  491.   PROCEDURE endPoplist*{"MuiBasics.EndPoplist"};
  492.   PROCEDURE EndPoplist*():m.Object; BEGIN RETURN EndObject( m.cPoplist ) END EndPoplist;
  493.   PROCEDURE endPopasl*{"MuiBasics.EndPopasl"};
  494.   PROCEDURE EndPopasl*():m.Object; BEGIN RETURN EndObject( m.cPopasl ) END EndPopasl;
  495.   PROCEDURE endScrmodelist*{"MuiBasics.EndScrmodelist"};
  496.   PROCEDURE EndScrmodelist*():m.Object; BEGIN RETURN EndObject( m.cScrmodelist ) END EndScrmodelist;
  497.   PROCEDURE endVGroup*{"MuiBasics.EndVGroup"};
  498.   PROCEDURE EndVGroup*():m.Object; BEGIN RETURN EndGroup(); END EndVGroup;
  499.   PROCEDURE endHGroup*{"MuiBasics.EndHGroup"};
  500.   PROCEDURE EndHGroup*():m.Object; BEGIN RETURN EndGroup(); END EndHGroup;
  501.   PROCEDURE endColGroup*{"MuiBasics.EndColGroup"};
  502.   PROCEDURE EndColGroup*():m.Object; BEGIN RETURN EndGroup(); END EndColGroup;
  503.   PROCEDURE endRowGroup*{"MuiBasics.EndRowGroup"};
  504.   PROCEDURE EndRowGroup*():m.Object; BEGIN RETURN EndGroup(); END EndRowGroup;
  505.   PROCEDURE endPageGroup*{"MuiBasics.EndPageGroup"};
  506.   PROCEDURE EndPageGroup*():m.Object; BEGIN RETURN EndGroup(); END EndPageGroup;
  507.   PROCEDURE endVGroupV*{"MuiBasics.EndVGroupV"};
  508.   PROCEDURE EndVGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndVGroupV;
  509.   PROCEDURE endHGroupV*{"MuiBasics.EndHGroupV"};
  510.   PROCEDURE EndHGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndHGroupV;
  511.   PROCEDURE endColGroupV*{"MuiBasics.EndColGroupV"};
  512.   PROCEDURE EndColGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndColGroupV;
  513.   PROCEDURE endRowGroupV*{"MuiBasics.EndRowGroupV"};
  514.   PROCEDURE EndRowGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndRowGroupV;
  515.   PROCEDURE endPageGroupV*{"MuiBasics.EndPageGroupV"};
  516.   PROCEDURE EndPageGroupV*():m.Object; BEGIN RETURN EndVirtgroup(); END EndPageGroupV;
  517.   PROCEDURE endRegisterGroup*{"MuiBasics.EndRegisterGroup"};
  518.   PROCEDURE EndRegisterGroup*():m.Object; BEGIN RETURN EndObject( m.cRegister ) END EndRegisterGroup;
  519.  
  520.   PROCEDURE NewObjectA*( name{8} : e.STRPTR; tags{9} : u.TagListPtr );
  521.     BEGIN
  522.       NewClass();
  523.       COPY( name^, no.tailPred(Class).name );
  524.       TagsA( tags );
  525.     END NewObjectA;
  526.  
  527.   PROCEDURE NewObject{"MuiBasics.NewObjectA"} ( name {8} : ARRAY OF CHAR; tags{9}.. : u.Tag );
  528.  
  529.  
  530.   PROCEDURE INewObjectA*( iclass{8} : I.IClassPtr; name{9}: e.STRPTR; tags{10} : u.TagListPtr );
  531.     BEGIN
  532.       NewClass();
  533.       IF name # NIL THEN
  534.         COPY( name^, no.tailPred(Class).name );
  535.       END;
  536.       no.tailPred(Class).iclass := iclass;
  537.       TagsA( tags );
  538.     END INewObjectA;
  539.  
  540.   PROCEDURE INewObject*{"MuiBasics.INewObjectA"}( iclass{8} : I.IClassPtr; name {9} : ARRAY OF CHAR; tags{10}.. : u.Tag );
  541.  
  542. (***************************************************************************
  543. ** Class Tree
  544. ****************************************************************************
  545. **
  546. ** rootclass               (B00PSI's base class)
  547. ** +--Notify               (implements notification mechanism)
  548. **    +--Family            (handles multiple children)
  549. **    !  +--Menustrip      (describes a complete menu strip)
  550. **    !  +--Menu           (describes a single menu)
  551. **    !  \--Menuitem       (describes a single menu item)
  552. **    +--Application       (main class for all applications)
  553. **    +--Window            (handles intuition window related topics)
  554. **    +--Area              (base class for all GUI elements)
  555. **       +--Rectangle      (creates (empty) rectangles)
  556. **       +--Image          (creates images)
  557. **       +--Text           (creates some text)
  558. **       +--String         (creates a string gadget)
  559. **       +--Prop           (creates a proportional gadget)
  560. **       +--Gauge          (creates a fule gauge)
  561. **       +--Scale          (creates a percentage scale)
  562. **       +--Boopsi         (interface to B00PSI gadgets)
  563. **       +--Colorfield     (creates a field with changeable color)
  564. **       +--List           (creates a line-oriented list)
  565. **       !  +--Floattext   (special list with floating text)
  566. **       !  +--Volumelist  (special list with volumes)
  567. **       !  +--Scrmodelist (special list with screen modes)
  568. **       !  \--Dirlist     (special list with files)
  569. **       +--Group          (groups other GUI elements)
  570. **          +--Register    (handles page groups with titles)
  571. **          +--Virtgroup   (handles virtual groups)
  572. **          +--Scrollgroup (handles virtual groups with scrollers)
  573. **          +--Scrollbar   (creates a scrollbar)
  574. **          +--Listview    (creates a listview)
  575. **          +--Radio       (creates radio buttons)
  576. **          +--Cycle       (creates cycle gadgets)
  577. **          +--Slider      (creates slider gadgets)
  578. **          +--Coloradjust (creates some RGB sliders)
  579. **          +--Palette     (creates a complete palette gadget)
  580. **          +--Colorpanel  (creates a panel of colors)
  581. **          +--Popstring   (base class for popups)
  582. **             +--Popobject(popup a MUI object in a window)
  583. **             \--Popasl   (popup an asl requester)
  584. **
  585. **************************************************************)
  586.  
  587. (**************************************************************************
  588. **
  589. ** Object Generation
  590. ** -----------------
  591. **
  592. ** The xxxObject (and xChilds) procedures generate new instances of MUI classes.
  593. ** Every xxxObject can be followed by tagitems specifying initial create
  594. ** time attributes for the new object and must be terminated with the
  595. ** End macro:
  596. **
  597. ** StringObject;
  598. **          TagItem2( m.aStringContents, "foo",
  599. **                    m.aStringMaxLen  , 40 );
  600. ** obj := End();
  601. **
  602. ** With the Child, SubWindow and WindowContents shortcuts you can
  603. ** construct a complete GUI within one command:
  604. **
  605. ** ApplicationObject;
  606. **
  607. **          ...
  608. **
  609. **          SubWindow; WindowObject;
  610. **             WindowContents; VGroup;
  611. **                Child; String("foo",40);
  612. **                Child; String("bar",50);
  613. **                Child; HGroup;
  614. **                   Child; CheckMark(TRUE);
  615. **                   Child; CheckMark(FALSE);
  616. **                   end;
  617. **                end;
  618. **             end;
  619. **
  620. **          SubWindow; WindowObject;
  621. **             WindowContents; HGroup;
  622. **                Child; ...;
  623. **                Child; ...;
  624. **                end;
  625. **             end;
  626. **
  627. **          ...
  628. **
  629. ** app := End();
  630. **
  631. ***************************************************************************)
  632.  
  633.   PROCEDURE FamilyObject*{"MuiBasics.FamilyObjectA"} ( tags{9}.. : u.Tag);
  634.   PROCEDURE FamilyObjectA*( tags{9} : u.TagListPtr );
  635.     BEGIN
  636.       NewObjectA( y.ADR( m.cFamily ), tags );
  637.     END FamilyObjectA;
  638.  
  639.   PROCEDURE MenustripObject*{"MuiBasics.MenustripObjectA"} ( tags{9}.. : u.Tag);
  640.   PROCEDURE MenustripObjectA*( tags{9} : u.TagListPtr );
  641.     BEGIN
  642.       NewObjectA( y.ADR( m.cMenustrip ), tags );
  643.     END MenustripObjectA;
  644.  
  645.   PROCEDURE MenuObject*{"MuiBasics.MenuObjectA"} ( tags{9}.. : u.Tag);
  646.   PROCEDURE MenuObjectA*( tags{9} : u.TagListPtr );
  647.     BEGIN
  648.       NewObjectA( y.ADR( m.cMenu ), tags );
  649.     END MenuObjectA;
  650.  
  651.   PROCEDURE MenuObjectT*{"MuiBasics.MenuObjectTA"} ( name{8}:e.STRPTR; tags{9}.. : u.Tag);
  652.   PROCEDURE MenuObjectTA*( name{8}:e.STRPTR; tags{9} : u.TagListPtr );
  653.     BEGIN
  654.       MenuObject( m.aMenuTitle, name, u.done );
  655.       TagsA( tags );
  656.     END MenuObjectTA;
  657.  
  658.   PROCEDURE MenuitemObject*{"MuiBasics.MenuitemObjectA"} ( tags{9}.. : u.Tag);
  659.   PROCEDURE MenuitemObjectA*( tags{9} : u.TagListPtr );
  660.     BEGIN
  661.       NewObjectA( y.ADR( m.cMenuitem ), tags );
  662.     END MenuitemObjectA;
  663.  
  664.   PROCEDURE WindowObject*{"MuiBasics.WindowObjectA"} ( tags{9}.. : u.Tag);
  665.   PROCEDURE WindowObjectA*( tags{9} : u.TagListPtr );
  666.     BEGIN
  667.       NewObjectA( y.ADR( m.cWindow ), tags );
  668.     END WindowObjectA;
  669.  
  670.   PROCEDURE ImageObject*{"MuiBasics.ImageObjectA"} ( tags{9}.. : u.Tag);
  671.   PROCEDURE ImageObjectA*( tags{9} : u.TagListPtr );
  672.     BEGIN
  673.       NewObjectA( y.ADR( m.cImage ), tags );
  674.     END ImageObjectA;
  675.  
  676.   PROCEDURE BitmapObject*{"MuiBasics.BitmapObjectA"} ( tags{9}.. : u.Tag);
  677.   PROCEDURE BitmapObjectA*( tags{9} : u.TagListPtr );
  678.     BEGIN
  679.       NewObjectA( y.ADR( m.cBitmap ), tags );
  680.     END BitmapObjectA;
  681.  
  682.   PROCEDURE BodychunkObject*{"MuiBasics.BodychunkObjectA"} ( tags{9}.. : u.Tag);
  683.   PROCEDURE BodychunkObjectA*( tags{9} : u.TagListPtr );
  684.     BEGIN
  685.       NewObjectA( y.ADR( m.cBodychunk ), tags );
  686.     END BodychunkObjectA;
  687.  
  688.   PROCEDURE NotifyObject*{"MuiBasics.NotifyObjectA"} ( tags{9}.. : u.Tag);
  689.   PROCEDURE NotifyObjectA*( tags{9} : u.TagListPtr );
  690.     BEGIN
  691.       NewObjectA( y.ADR( m.cNotify ), tags );
  692.     END NotifyObjectA;
  693.  
  694.   PROCEDURE ApplicationObject*{"MuiBasics.ApplicationObjectA"} ( tags{9}.. : u.Tag);
  695.   PROCEDURE ApplicationObjectA*( tags{9} : u.TagListPtr );
  696.     BEGIN
  697.       NewObjectA( y.ADR( m.cApplication ), tags );
  698.     END ApplicationObjectA;
  699.  
  700.   PROCEDURE TextObject*{"MuiBasics.TextObjectA"} ( tags{9}.. : u.Tag);
  701.   PROCEDURE TextObjectA*( tags{9} : u.TagListPtr );
  702.     BEGIN
  703.       NewObjectA( y.ADR( m.cText ), tags );
  704.     END TextObjectA;
  705.  
  706.   PROCEDURE RectangleObject*{"MuiBasics.RectangleObjectA"} ( tags{9}.. : u.Tag);
  707.   PROCEDURE RectangleObjectA*( tags{9} : u.TagListPtr );
  708.     BEGIN
  709.       NewObjectA( y.ADR( m.cRectangle ), tags );
  710.     END RectangleObjectA;
  711.  
  712.   PROCEDURE ListObject*{"MuiBasics.ListObjectA"} ( tags{9}.. : u.Tag);
  713.   PROCEDURE ListObjectA*( tags{9} : u.TagListPtr );
  714.     BEGIN
  715.       NewObjectA( y.ADR( m.cList ), tags );
  716.     END ListObjectA;
  717.  
  718.   PROCEDURE PropObject*{"MuiBasics.PropObjectA"} ( tags{9}.. : u.Tag);
  719.   PROCEDURE PropObjectA*( tags{9} : u.TagListPtr );
  720.     BEGIN
  721.       NewObjectA( y.ADR( m.cProp ), tags );
  722.     END PropObjectA;
  723.  
  724.   PROCEDURE StringObject*{"MuiBasics.StringObjectA"} ( tags{9}.. : u.Tag);
  725.   PROCEDURE StringObjectA*( tags{9} : u.TagListPtr );
  726.     BEGIN
  727.       NewObjectA( y.ADR( m.cString ), tags );
  728.     END StringObjectA;
  729.  
  730.   PROCEDURE ScrollbarObject*{"MuiBasics.ScrollbarObjectA"} ( tags{9}.. : u.Tag);
  731.   PROCEDURE ScrollbarObjectA*( tags{9} : u.TagListPtr );
  732.     BEGIN
  733.       NewObjectA( y.ADR( m.cScrollbar ), tags );
  734.     END ScrollbarObjectA;
  735.  
  736.   PROCEDURE ListviewObject*{"MuiBasics.ListviewObjectA"} ( tags{9}.. : u.Tag);
  737.   PROCEDURE ListviewObjectA*( tags{9} : u.TagListPtr );
  738.     BEGIN
  739.       NewObjectA( y.ADR( m.cListview), tags );
  740.     END ListviewObjectA;
  741.  
  742.   PROCEDURE RadioObject*{"MuiBasics.RadioObjectA"} ( tags{9}.. : u.Tag);
  743.   PROCEDURE RadioObjectA*( tags{9} : u.TagListPtr );
  744.     BEGIN
  745.       NewObjectA( y.ADR( m.cRadio ), tags );
  746.     END RadioObjectA;
  747.  
  748.   PROCEDURE VolumelistObject*{"MuiBasics.VolumelistObjectA"} ( tags{9}.. : u.Tag);
  749.   PROCEDURE VolumelistObjectA*( tags{9} : u.TagListPtr );
  750.     BEGIN
  751.       NewObjectA( y.ADR( m.cVolumelist), tags );
  752.     END VolumelistObjectA;
  753.  
  754.   PROCEDURE FloattextObject*{"MuiBasics.FloattextObjectA"} ( tags{9}.. : u.Tag);
  755.   PROCEDURE FloattextObjectA*( tags{9} : u.TagListPtr );
  756.     BEGIN
  757.       NewObjectA( y.ADR( m.cFloattext), tags );
  758.     END FloattextObjectA;
  759.  
  760.   PROCEDURE DirlistObject*{"MuiBasics.DirlistObjectA"} ( tags{9}.. : u.Tag);
  761.   PROCEDURE DirlistObjectA*( tags{9} : u.TagListPtr );
  762.     BEGIN
  763.       NewObjectA( y.ADR( m.cDirlist ), tags );
  764.     END DirlistObjectA;
  765.  
  766.   PROCEDURE SliderObject*{"MuiBasics.SliderObjectA"} ( tags{9}.. : u.Tag);
  767.   PROCEDURE SliderObjectA*( tags{9} : u.TagListPtr );
  768.     BEGIN
  769.       NewObjectA( y.ADR( m.cSlider ), tags );
  770.     END SliderObjectA;
  771.  
  772.   PROCEDURE CycleObject*{"MuiBasics.CycleObjectA"} ( tags{9}.. : u.Tag);
  773.   PROCEDURE CycleObjectA*( tags{9} : u.TagListPtr );
  774.     BEGIN
  775.       NewObjectA( y.ADR( m.cCycle ), tags );
  776.     END CycleObjectA;
  777.  
  778.   PROCEDURE GaugeObject*{"MuiBasics.GaugeObjectA"} ( tags{9}.. : u.Tag);
  779.   PROCEDURE GaugeObjectA*( tags{9} : u.TagListPtr );
  780.     BEGIN
  781.       NewObjectA( y.ADR( m.cGauge ), tags );
  782.     END GaugeObjectA;
  783.  
  784.   PROCEDURE ScaleObject*{"MuiBasics.ScaleObjectA"} ( tags{9}.. : u.Tag);
  785.   PROCEDURE ScaleObjectA*( tags{9} : u.TagListPtr );
  786.     BEGIN
  787.       NewObjectA( y.ADR( m.cScale ), tags );
  788.     END ScaleObjectA;
  789.  
  790.   PROCEDURE BoopsiObject*{"MuiBasics.BoopsiObjectA"} ( tags{9}.. : u.Tag);
  791.   PROCEDURE BoopsiObjectA*( tags{9} : u.TagListPtr );
  792.     BEGIN
  793.       NewObjectA( y.ADR( m.cBoopsi ), tags );
  794.     END BoopsiObjectA;
  795.  
  796.   PROCEDURE ColorfieldObject*{"MuiBasics.ColorfieldObjectA"} ( tags{9}.. : u.Tag);
  797.   PROCEDURE ColorfieldObjectA*( tags{9} : u.TagListPtr );
  798.     BEGIN
  799.       NewObjectA( y.ADR( m.cColorfield ), tags );
  800.     END ColorfieldObjectA;
  801.  
  802.   PROCEDURE ColorpanelObject*{"MuiBasics.ColorpanelObjectA"} ( tags{9}.. : u.Tag);
  803.   PROCEDURE ColorpanelObjectA*( tags{9} : u.TagListPtr );
  804.     BEGIN
  805.       NewObjectA( y.ADR( m.cColorpanel ), tags );
  806.     END ColorpanelObjectA;
  807.  
  808.   PROCEDURE ColoradjustObject*{"MuiBasics.ColoradjustObjectA"} ( tags{9}.. : u.Tag);
  809.   PROCEDURE ColoradjustObjectA*( tags{9} : u.TagListPtr );
  810.     BEGIN
  811.       NewObjectA( y.ADR( m.cColoradjust ), tags );
  812.     END ColoradjustObjectA;
  813.  
  814.   PROCEDURE PaletteObject*{"MuiBasics.PaletteObjectA"} ( tags{9}.. : u.Tag);
  815.   PROCEDURE PaletteObjectA*( tags{9} : u.TagListPtr );
  816.     BEGIN
  817.       NewObjectA( y.ADR( m.cPalette ), tags );
  818.     END PaletteObjectA;
  819.  
  820.   PROCEDURE GroupObject*{"MuiBasics.GroupObjectA"} ( tags{9}.. : u.Tag);
  821.   PROCEDURE GroupObjectA*( tags{9} : u.TagListPtr );
  822.     BEGIN
  823.       NewObjectA( y.ADR( m.cGroup), tags );
  824.     END GroupObjectA;
  825.  
  826.   PROCEDURE RegisterObject*{"MuiBasics.RegisterObjectA"} ( tags{9}.. : u.Tag);
  827.   PROCEDURE RegisterObjectA*( tags{9} : u.TagListPtr );
  828.     BEGIN
  829.       NewObjectA( y.ADR( m.cRegister ), tags );
  830.     END RegisterObjectA;
  831.  
  832.   PROCEDURE VirtgroupObject*{"MuiBasics.VirtgroupObjectA"} ( tags{9}.. : u.Tag);
  833.   PROCEDURE VirtgroupObjectA*( tags{9} : u.TagListPtr );
  834.     BEGIN
  835.       NewObjectA( y.ADR( m.cVirtgroup ), tags );
  836.     END VirtgroupObjectA;
  837.  
  838.   PROCEDURE ScrollgroupObject*{"MuiBasics.ScrollgroupObjectA"} ( tags{9}.. : u.Tag);
  839.   PROCEDURE ScrollgroupObjectA*( tags{9} : u.TagListPtr );
  840.     BEGIN
  841.       NewObjectA( y.ADR( m.cScrollgroup ), tags );
  842.     END ScrollgroupObjectA;
  843.  
  844.   PROCEDURE PopstringObject*{"MuiBasics.PopstringObjectA"} ( tags{9}.. : u.Tag);
  845.   PROCEDURE PopstringObjectA*( tags{9} : u.TagListPtr );
  846.     BEGIN
  847.       NewObjectA( y.ADR( m.cPopstring ), tags );
  848.     END PopstringObjectA;
  849.  
  850.   PROCEDURE PopobjectObject*{"MuiBasics.PopobjectObjectA"} ( tags{9}.. : u.Tag);
  851.   PROCEDURE PopobjectObjectA*( tags{9} : u.TagListPtr );
  852.     BEGIN
  853.       NewObjectA( y.ADR( m.cPopobject ), tags );
  854.     END PopobjectObjectA;
  855.  
  856.   PROCEDURE PoplistObject*{"MuiBasics.PoplistObjectA"} ( tags{9}.. : u.Tag);
  857.   PROCEDURE PoplistObjectA*( tags{9} : u.TagListPtr );
  858.     BEGIN
  859.       NewObjectA( y.ADR( m.cPoplist ), tags );
  860.     END PoplistObjectA;
  861.  
  862.   PROCEDURE PopaslObject*{"MuiBasics.PopaslObjectA"} ( tags{9}.. : u.Tag);
  863.   PROCEDURE PopaslObjectA*( tags{9} : u.TagListPtr );
  864.     BEGIN
  865.       NewObjectA( y.ADR( m.cPopasl ), tags );
  866.     END PopaslObjectA;
  867.  
  868.   PROCEDURE ScrmodelistObject*{"MuiBasics.ScrmodelistObjectA"} ( tags{9}.. : u.Tag);
  869.   PROCEDURE ScrmodelistObjectA*( tags{9} : u.TagListPtr );
  870.     BEGIN
  871.       NewObjectA( y.ADR( m.cScrmodelist ), tags );
  872.     END ScrmodelistObjectA;
  873.  
  874.   PROCEDURE VGroup*{"MuiBasics.VGroupA"}( tags{9}.. : u.Tag );
  875.   PROCEDURE VGroupA*( tags{9} : u.TagListPtr );
  876.     BEGIN
  877.       NewObjectA( y.ADR( m.cGroup ), tags );
  878.       TagsA( tags );
  879.     END VGroupA;
  880.  
  881.   PROCEDURE HGroup*{"MuiBasics.HGroupA"}( tags{9}.. : u.Tag );
  882.   PROCEDURE HGroupA*( tags{9} : u.TagListPtr );
  883.     BEGIN
  884.       NewObject( m.cGroup, m.aGroupHoriz, e.true, u.end );
  885.       TagsA( tags );
  886.     END HGroupA;
  887.  
  888.   PROCEDURE ColGroup*{"MuiBasics.ColGroupA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  889.   PROCEDURE ColGroupA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  );
  890.     BEGIN
  891.       NewObject( m.cGroup, m.aGroupColumns, cols, u.end );
  892.       TagsA( tags );
  893.     END ColGroupA;
  894.  
  895.   PROCEDURE RowGroup*{"MuiBasics.RowGroupA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  );
  896.   PROCEDURE RowGroupA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  );
  897.     BEGIN
  898.       NewObject( m.cGroup, m.aGroupRows, rows, u.end );
  899.       TagsA( tags );
  900.     END RowGroupA;
  901.  
  902.   PROCEDURE PageGroup*{"MuiBasics.PageGroupA"}( tags{9}.. : u.Tag );
  903.   PROCEDURE PageGroupA*( tags{9} : u.TagListPtr );
  904.     BEGIN
  905.       NewObject( m.cGroup, m.aGroupPageMode, e.true, u.end );
  906.       TagsA( tags );
  907.     END PageGroupA;
  908.  
  909.   PROCEDURE VGroupV*{"MuiBasics.VGroupAV"}( tags{9}.. : u.Tag );
  910.   PROCEDURE VGroupAV*( tags{9} : u.TagListPtr );
  911.     BEGIN
  912.       NewObjectA( y.ADR( m.cVirtgroup ), tags );
  913.       TagsA( tags );
  914.     END VGroupAV;
  915.  
  916.   PROCEDURE HGroupV*{"MuiBasics.HGroupAV"}( tags{9}.. : u.Tag );
  917.   PROCEDURE HGroupAV*( tags{9} : u.TagListPtr );
  918.     BEGIN
  919.       NewObject( m.cVirtgroup, m.aGroupHoriz, e.true, u.end );
  920.       TagsA( tags );
  921.     END HGroupAV;
  922.  
  923.   PROCEDURE ColGroupV*{"MuiBasics.ColGroupAV"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  924.   PROCEDURE ColGroupAV*( cols{3} : LONGINT; tags{9} : u.TagListPtr  );
  925.     BEGIN
  926.       NewObject( m.cVirtgroup, m.aGroupColumns, cols, u.end );
  927.       TagsA( tags );
  928.     END ColGroupAV;
  929.  
  930.   PROCEDURE RowGroupV*{"MuiBasics.RowGroupAV"}( rows{3} : LONGINT; tags{9}.. : u.Tag  );
  931.   PROCEDURE RowGroupAV*( rows{3} : LONGINT; tags{9} : u.TagListPtr  );
  932.     BEGIN
  933.       NewObject( m.cVirtgroup, m.aGroupRows, rows, u.end );
  934.       TagsA( tags );
  935.     END RowGroupAV;
  936.  
  937.   PROCEDURE PageGroupV*{"MuiBasics.PageGroupAV"}( tags{9}.. : u.Tag );
  938.   PROCEDURE PageGroupAV*( tags{9} : u.TagListPtr );
  939.     BEGIN
  940.       NewObject( m.cVirtgroup, m.aGroupPageMode, e.true, u.end );
  941.       TagsA( tags );
  942.     END PageGroupAV;
  943.  
  944.   PROCEDURE RegisterGroup*{"MuiBasics.RegisterGroupA"}( t{8} : e.APTR; tags{9}.. : u.Tag );
  945.   PROCEDURE RegisterGroupA*( t{8} : e.APTR; tags{9} : u.TagListPtr );
  946.     BEGIN
  947.       NewObject( m.cRegister, m.aRegisterTitles, t, u.end );
  948.       TagsA( tags );
  949.     END RegisterGroupA;
  950.  
  951.   PROCEDURE Child*();
  952.     BEGIN
  953.       Tag( m.aGroupChild );
  954.     END Child;
  955.  
  956.   PROCEDURE SubWindow*();
  957.     BEGIN
  958.       Tag( m.aApplicationWindow );
  959.     END SubWindow;
  960.  
  961.   PROCEDURE WindowContents*();
  962.     BEGIN
  963.       Tag( m.aWindowRootObject );
  964.     END WindowContents;
  965.  
  966. (***************************************************************************
  967. **
  968. ** Frame Types
  969. ** -----------
  970. **
  971. ** These procedures may be used to specify one of MUI's different frame types.
  972. ** Note that every procedure consists of one or more { ti_Tag, ti_Data }
  973. ** pairs.
  974. **
  975. ** GroupFrameT() is a special kind of frame that contains a centered
  976. ** title text.
  977. **
  978. ** HGroup; GroupFrameT("Horiz Groups");
  979. **    Child; RectangleObject; TextFrame  ; end;
  980. **    Child; RectangleObject; StringFrame; end;
  981. **    Child; RectangleObject; ButtonFrame; end;
  982. **    Child; RectangleObject; ListFrame  ; end;
  983. **    end;
  984. **
  985. ***************************************************************************)
  986.  
  987.   PROCEDURE NoFrame*{"MuiBasics.NoFrameA"} ( tags{9}.. : u.Tag );
  988.   PROCEDURE NoFrameA*( tags{9} : u.TagListPtr );
  989.     BEGIN
  990.       TagItem( m.aFrame , m.vFrameNone );
  991.       TagsA( tags );
  992.     END NoFrameA;
  993.  
  994.   PROCEDURE ButtonFrame*{"MuiBasics.ButtonFrameA"} ( tags{9}.. : u.Tag  );
  995.   PROCEDURE ButtonFrameA*( tags{9} : u.TagListPtr  );
  996.     BEGIN
  997.       TagItem( m.aFrame , m.vFrameButton );
  998.       TagsA( tags );
  999.     END ButtonFrameA;
  1000.  
  1001.   PROCEDURE ImageButtonFrame*{"MuiBasics.ImageButtonFrameA"} ( tags{9}.. : u.Tag );
  1002.   PROCEDURE ImageButtonFrameA*( tags{9} : u.TagListPtr );
  1003.     BEGIN
  1004.       TagItem( m.aFrame , m.vFrameImageButton );
  1005.       TagsA( tags );
  1006.     END ImageButtonFrameA;
  1007.  
  1008.   PROCEDURE TextFrame*{"MuiBasics.TextFrameA"} ( tags{9}.. : u.Tag );
  1009.   PROCEDURE TextFrameA*( tags{9} : u.TagListPtr );
  1010.     BEGIN
  1011.       TagItem( m.aFrame , m.vFrameText );
  1012.       TagsA( tags );
  1013.     END TextFrameA;
  1014.  
  1015.   PROCEDURE StringFrame*{"MuiBasics.StringFrameA"} ( tags{9}.. : u.Tag );
  1016.   PROCEDURE StringFrameA*( tags{9} : u.TagListPtr );
  1017.     BEGIN
  1018.       TagItem( m.aFrame , m.vFrameString );
  1019.       TagsA( tags );
  1020.     END StringFrameA;
  1021.  
  1022.   PROCEDURE ReadListFrame*{"MuiBasics.ReadListFrameA"} ( tags{9}.. : u.Tag );
  1023.   PROCEDURE ReadListFrameA*( tags{9} : u.TagListPtr );
  1024.     BEGIN
  1025.       TagItem(  m.aFrame , m.vFrameReadList );
  1026.       TagsA( tags );
  1027.     END ReadListFrameA;
  1028.  
  1029.   PROCEDURE InputListFrame*{"MuiBasics.InputListFrameA"} ( tags{9}.. : u.Tag );
  1030.   PROCEDURE InputListFrameA*( tags{9} : u.TagListPtr );
  1031.     BEGIN
  1032.       TagItem( m.aFrame , m.vFrameInputList );
  1033.       TagsA( tags );
  1034.     END InputListFrameA;
  1035.  
  1036.   PROCEDURE PropFrame*{"MuiBasics.PropFrameA"} ( tags{9}.. : u.Tag );
  1037.   PROCEDURE PropFrameA*( tags{9} : u.TagListPtr );
  1038.     BEGIN
  1039.       TagItem( m.aFrame , m.vFrameProp );
  1040.       TagsA( tags );
  1041.     END PropFrameA;
  1042.  
  1043.   PROCEDURE SliderFrame*{"MuiBasics.SliderFrameA"} ( tags{9}.. : u.Tag );
  1044.   PROCEDURE SliderFrameA*( tags{9} : u.TagListPtr );
  1045.     BEGIN
  1046.       TagItem( m.aFrame , m.vFrameSlider );
  1047.       TagsA( tags );
  1048.     END SliderFrameA;
  1049.  
  1050.   PROCEDURE GaugeFrame*{"MuiBasics.GaugeFrameA"} ( tags{9}.. : u.Tag );
  1051.   PROCEDURE GaugeFrameA*( tags{9} : u.TagListPtr );
  1052.     BEGIN
  1053.       TagItem( m.aFrame , m.vFrameGauge );
  1054.       TagsA( tags );
  1055.     END GaugeFrameA;
  1056.  
  1057.   PROCEDURE VirtualFrame*{"MuiBasics.VirtualFrameA"} ( tags{9}.. : u.Tag );
  1058.   PROCEDURE VirtualFrameA*( tags{9} : u.TagListPtr );
  1059.     BEGIN
  1060.       TagItem( m.aFrame , m.vFrameVirtual );
  1061.       TagsA( tags );
  1062.     END VirtualFrameA;
  1063.  
  1064.   PROCEDURE GroupFrame*{"MuiBasics.GroupFrameA"} ( tags{9}.. : u.Tag );
  1065.   PROCEDURE GroupFrameA*( tags{9} : u.TagListPtr );
  1066.     BEGIN
  1067.       TagItem( m.aFrame , m.vFrameGroup );
  1068.       TagsA( tags );
  1069.     END GroupFrameA;
  1070.  
  1071.   PROCEDURE GroupFrameT*{"MuiBasics.GroupFrameTA"}( s{8} : ARRAY OF CHAR; tags{9}.. : u.Tag );
  1072.   PROCEDURE GroupFrameTA*( s{8} : e.STRPTR; tags{9} : u.TagListPtr );
  1073.     BEGIN
  1074.       TagItem2( m.aFrame, m.vFrameGroup, m.aFrameTitle, s );
  1075.       TagsA( tags );
  1076.     END GroupFrameTA;
  1077.  
  1078. (***************************************************************************
  1079. **
  1080. ** Baring Procedures
  1081. ** ------------------
  1082. **
  1083. ***************************************************************************)
  1084.  
  1085.   PROCEDURE HBar*();
  1086.     BEGIN
  1087.       Tag( m.NewObject( m.cRectangle,
  1088.                         m.aRectangleHBar, e.true,
  1089.                         m.aFixHeight, 2,
  1090.                         u.done ) );
  1091.     END HBar;
  1092.  
  1093.   PROCEDURE VBar*();
  1094.     BEGIN
  1095.       Tag( m.NewObject( m.cRectangle,
  1096.                         m.aRectangleVBar, e.true,
  1097.                         m.aFixWidth, 2,
  1098.                         u.done ) );
  1099.     END VBar;
  1100.  
  1101. (***************************************************************************
  1102. **
  1103. ** Spacing Procedures
  1104. ** ------------------
  1105. **
  1106. ***************************************************************************)
  1107.  
  1108.   PROCEDURE GroupSpacing*( x: LONGINT );
  1109.     BEGIN
  1110.       TagItem( m.aGroupSpacing, x );
  1111.     END GroupSpacing;
  1112.  
  1113.   PROCEDURE HVSpace*();
  1114.     BEGIN
  1115.       Tag( m.NewObject( m.cRectangle, u.done ) );
  1116.     END HVSpace;
  1117.  
  1118.   PROCEDURE HSpace*( x : LONGINT );
  1119.     VAR t : u.Tags3;
  1120.     BEGIN
  1121.       IF x # 0 THEN
  1122.         t[0].tag := m.aFixWidth;
  1123.         t[0].data := x;
  1124.       ELSE
  1125.         t[0].tag := u.ignore;
  1126.       END;
  1127.       t[1] := u.TagItem( m.aVertWeight, 0 );
  1128.       t[2] := u.TagItem( u.done, 0 );
  1129.       Tag( m.NewObjectA( m.cRectangle, t ) );
  1130.     END HSpace;
  1131.  
  1132.   PROCEDURE VSpace*( x : LONGINT );
  1133.     VAR t : u.Tags3;
  1134.     BEGIN
  1135.       IF x # 0 THEN
  1136.         t[0].tag := m.aFixHeight;
  1137.         t[0].data := x;
  1138.       ELSE
  1139.         t[0].tag := u.ignore;
  1140.       END;
  1141.       t[1] := u.TagItem( m.aHorizWeight, 0 );
  1142.       t[2] := u.TagItem( u.done, 0 );
  1143.       Tag( m.NewObjectA( m.cRectangle, t ) );
  1144.     END VSpace;
  1145.  
  1146.   PROCEDURE HCenterBegin*();
  1147.     BEGIN
  1148.       HGroup; GroupSpacing( 0 );
  1149.         Child; HSpace( 0 );
  1150.     END HCenterBegin;
  1151.  
  1152.   PROCEDURE HCenterEnd*();
  1153.     BEGIN
  1154.         Child; HSpace( 0 );
  1155.       end;
  1156.     END HCenterEnd;
  1157.  
  1158.   PROCEDURE VCenterBegin*();
  1159.     BEGIN
  1160.       VGroup; GroupSpacing( 0 );
  1161.         Child ; VSpace( 0 );
  1162.     END VCenterBegin;
  1163.  
  1164.   PROCEDURE VCenterEnd*();
  1165.     BEGIN
  1166.         Child ; VSpace( 0 );
  1167.       end;
  1168.     END VCenterEnd;
  1169.  
  1170.   PROCEDURE InnerSpacing*( h, v : LONGINT );
  1171.     BEGIN
  1172.       Tags( m.aInnerLeft   , h,
  1173.             m.aInnerRight  , h,
  1174.             m.aInnerTop    , v,
  1175.             m.aInnerBottom , v,
  1176.             u.end );
  1177.     END InnerSpacing;
  1178.  
  1179.  
  1180. (***************************************************************************
  1181. **
  1182. ** String-Object
  1183. ** -------------
  1184. **
  1185. ** The following procedure creates a simple string gadget.
  1186. **
  1187. ***************************************************************************)
  1188.  
  1189.   PROCEDURE String * {"MuiBasics.StringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1190.   PROCEDURE string * {"MuiBasics.StringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; tags{9}.. : u.Tag );
  1191.   PROCEDURE StringA*( contents{8} : e.STRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1192.     BEGIN
  1193.       StringObject; StringFrame;
  1194.         TagItem2( m.aStringMaxLen, maxlen,
  1195.                   m.aStringContents, contents );
  1196.         TagsA( tags );
  1197.       RETURN End();
  1198.     END StringA;
  1199.  
  1200.   PROCEDURE KeyString * {"MuiBasics.KeyStringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  1201.   PROCEDURE keyString * {"MuiBasics.KeyStringA"} ( contents{8} : e.STRPTR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag );
  1202.   PROCEDURE KeyStringA*( contents{8} : e.STRPTR; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1203.     BEGIN
  1204.         y.INLINE( 0284H, 0000H, 00FFH );  (* andi.l  #000000FF,d4 *)
  1205.       RETURN String( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
  1206.     END KeyStringA;
  1207.  
  1208. (***************************************************************************
  1209. **
  1210. ** Integer-Object
  1211. ** --------------
  1212. **
  1213. ** The following procedure creates a simple integer string gadget.
  1214. **
  1215. ***************************************************************************)
  1216.  
  1217.   PROCEDURE Integer * {"MuiBasics.IntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1218.   PROCEDURE integer * {"MuiBasics.IntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; tags{9}.. : u.Tag );
  1219.   PROCEDURE IntegerA*( contents{2} : e.STRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1220.     BEGIN
  1221.       StringObject; StringFrame;
  1222.         TagItem3( m.aStringMaxLen, maxlen,
  1223.                   m.aStringInteger, contents,
  1224.                   m.aStringAccept, y.ADR( "0123456789" ) );
  1225.  
  1226.         TagsA( tags );
  1227.       RETURN End();
  1228.     END IntegerA;
  1229.  
  1230.  
  1231.   PROCEDURE KeyInteger * {"MuiBasics.KeyIntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  1232.   PROCEDURE keyInteger * {"MuiBasics.KeyIntegerA"} ( contents{2} : LONGINT; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag );
  1233.   PROCEDURE KeyIntegerA*( contents{2} : LONGINT; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1234.     BEGIN
  1235.         y.INLINE( 0284H, 0000H, 00FFH );  (* andi.l  #000000FF,d4 *)
  1236.       RETURN Integer( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
  1237.     END KeyIntegerA;
  1238.  
  1239.  
  1240. (***************************************************************************
  1241. **
  1242. ** CheckMark-Object
  1243. ** ----------------
  1244. **
  1245. ** The following procedure creates a checkmark gadget.
  1246. **
  1247. ***************************************************************************)
  1248.  
  1249.   PROCEDURE CheckMark * {"MuiBasics.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag ):m.Object;
  1250.   PROCEDURE checkMark * {"MuiBasics.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag );
  1251.   PROCEDURE CheckMarkA*( checked{4} : e.LONGBOOL; tags{9} : u.TagListPtr ):m.Object;
  1252.    BEGIN
  1253.         y.INLINE( 0284H, 0000H, 00FFH );  (* andi.l  #000000FF,d4 *)
  1254.       ImageObject;
  1255.         ImageButtonFrame;
  1256.           Tags( m.aInputMode , m.vInputModeToggle,
  1257.                 m.aImageSpec    , m.iCheckMark,
  1258.                 m.aImageFreeVert, e.true,
  1259.                 m.aSelected     , checked,
  1260.                 m.aBackground   , m.iButtonBack,
  1261.                 m.aShowSelState , e.false,
  1262.                 u.end );
  1263.           TagsA( tags );
  1264.       RETURN End();
  1265.     END CheckMarkA;
  1266.  
  1267.  
  1268.   PROCEDURE KeyCheckMark *{"MuiBasics.KeyCheckMarkA"}( checked{4} : BOOLEAN; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1269.   PROCEDURE keyCheckMark *{"MuiBasics.KeyCheckMarkA"}( checked{4} : BOOLEAN; key{3} : CHAR; tags{9}.. : u.Tag );
  1270.   PROCEDURE KeyCheckMarkA*( checked{4} : e.LONGBOOL; key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1271.    BEGIN
  1272.         y.INLINE( 0283H, 0000H, 00FFH );  (* andi.l  #000000FF,d3 *)
  1273.         y.INLINE( 0284H, 0000H, 00FFH );  (* andi.l  #000000FF,d4 *)
  1274.       RETURN  CheckMark( y.VAL( BOOLEAN, SHORT(SHORT(checked)) ), m.aControlChar, key, u.more, tags );
  1275.     END KeyCheckMarkA;
  1276.  
  1277.  
  1278. (***************************************************************************
  1279. **
  1280. ** Button-Objects
  1281. ** --------------
  1282. **
  1283. ** Note: Use small letters for KeyButtons, e.g.
  1284. **       KeyButton("Cancel",'c')  and not  KeyButton("Cancel",'C') !!
  1285. **
  1286. ***************************************************************************)
  1287.  
  1288.   PROCEDURE SimpleButton * {"MuiBasics.SimpleButtonA"} ( name{8} : ARRAY OF CHAR; tags{9}.. : u.Tag ):m.Object;
  1289.   PROCEDURE simpleButton * {"MuiBasics.SimpleButtonA"} ( name{8} : ARRAY OF CHAR; tags{9}.. : u.Tag );
  1290.   PROCEDURE SimpleButtonA * ( name{8} : e.STRPTR; tags{9} : u.TagListPtr ):m.Object;
  1291.     BEGIN
  1292.       TextObject;
  1293.         ButtonFrame;
  1294.           Tags( m.aTextContents, name,
  1295.                 m.aTextPreParse, y.ADR("\033c"),
  1296.                 m.aTextSetMax  , e.false,
  1297.                 m.aInputMode   , m.vInputModeRelVerify,
  1298.                 m.aBackground  , m.iButtonBack,
  1299.                 u.end );
  1300.         TagsA( tags );
  1301.       RETURN End();
  1302.     END SimpleButtonA;
  1303.  
  1304.  
  1305.   PROCEDURE KeyButton * {"MuiBasics.KeyButtonA"} ( name{8} : ARRAY OF CHAR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1306.   PROCEDURE keyButton * {"MuiBasics.KeyButtonA"} ( name{8} : ARRAY OF CHAR; key{4} : CHAR; tags{9}.. : u.Tag );
  1307.   PROCEDURE KeyButtonA * ( name{8} : e.STRPTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1308.     BEGIN
  1309.         y.INLINE( 0284H, 0000H, 00FFH );  (* andi.l  #000000FF,d4 *)
  1310.       RETURN SimpleButton( name^, m.aTextHiChar, key, m.aControlChar, key, u.more, tags );
  1311.     END KeyButtonA;
  1312.  
  1313. (***************************************************************************
  1314. **
  1315. ** Cycle-Object
  1316. ** ------------
  1317. **
  1318. ***************************************************************************)
  1319.  
  1320.   PROCEDURE Cycle * {"MuiBasics.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  1321.   PROCEDURE cycle * {"MuiBasics.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag );
  1322.   PROCEDURE CycleA * ( entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  1323.     BEGIN
  1324.       CycleObject( m.aCycleEntries, entries, u.end );
  1325.         TagsA( tags );
  1326.       RETURN End();
  1327.     END CycleA;
  1328.  
  1329.  
  1330.   PROCEDURE KeyCycle * {"MuiBasics.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1331.   PROCEDURE keyCycle * {"MuiBasics.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag );
  1332.   PROCEDURE KeyCycleA * ( entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1333.     BEGIN
  1334.         y.INLINE( 0284H, 0000H, 00FFH );  (* andi.l  #000000FF,d4 *)
  1335.       RETURN  Cycle( entries, m.aControlChar, key, u.more, tags );
  1336.     END KeyCycleA;
  1337.  
  1338.  
  1339. (***************************************************************************
  1340. **
  1341. ** Radio-Object
  1342. ** ------------
  1343. **
  1344. ***************************************************************************)
  1345.  
  1346.   PROCEDURE Radio * {"MuiBasics.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  1347.   PROCEDURE radio * {"MuiBasics.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag );
  1348.   PROCEDURE RadioA * ( name{8}: e.STRPTR; entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  1349.     BEGIN
  1350.       RadioObject;
  1351.         GroupFrameT( name^ );
  1352.           TagItem( m.aRadioEntries, entries );
  1353.         TagsA( tags );
  1354.       RETURN End();
  1355.     END RadioA;
  1356.  
  1357.   PROCEDURE KeyRadio * {"MuiBasics.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1358.   PROCEDURE keyRadio * {"MuiBasics.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag );
  1359.   PROCEDURE KeyRadioA * ( name{8}: e.STRPTR; entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1360.     BEGIN
  1361.         y.INLINE( 0284H, 0000H, 00FFH );  (* andi.l  #000000FF,d4 *)
  1362.       RETURN  Radio(name^, entries, m.aControlChar, key, u.more, tags );
  1363.     END KeyRadioA;
  1364.  
  1365.  
  1366. (***************************************************************************
  1367. **
  1368. ** Slider-Object
  1369. ** -------------
  1370. **
  1371. ***************************************************************************)
  1372.  
  1373.   PROCEDURE Slider * {"MuiBasics.SliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1374.   PROCEDURE slider * {"MuiBasics.SliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1375.   PROCEDURE SliderA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1376.     BEGIN
  1377.       SliderObject( m.aSliderMin, min,
  1378.                     m.aSliderMax, max,
  1379.                     m.aSliderLevel, level,
  1380.                     u.end );
  1381.         TagsA( tags );
  1382.       RETURN End();
  1383.     END SliderA;
  1384.  
  1385.   PROCEDURE KeySlider * {"MuiBasics.KeySliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1386.   PROCEDURE keySlider * {"MuiBasics.KeySliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1387.   PROCEDURE KeySliderA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1388.     BEGIN
  1389.         y.INLINE( 0285H, 0000H, 00FFH );  (* andi.l  #000000FF,d5 *)
  1390.       RETURN Slider( min, max, level, m.aControlChar, key, u.more, tags );
  1391.     END KeySliderA;
  1392.  
  1393.   PROCEDURE VSlider * {"MuiBasics.VSliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1394.   PROCEDURE vSlider * {"MuiBasics.VSliderA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1395.   PROCEDURE VSliderA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1396.     BEGIN
  1397.       RETURN Slider( min, max, level, m.aGroupHoriz, e.false, u.more, tags );
  1398.     END VSliderA;
  1399.  
  1400.  
  1401.   PROCEDURE KeyVSlider * {"MuiBasics.KeyVSliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1402.   PROCEDURE keyVSlider * {"MuiBasics.KeyVSliderA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1403.   PROCEDURE KeyVSliderA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1404.     BEGIN
  1405.         y.INLINE( 0285H, 0000H, 00FFH );  (* andi.l  #000000FF,d5 *)
  1406.       RETURN  VSlider( min, max, level, m.aControlChar, key, u.more, tags );
  1407.     END KeyVSliderA;
  1408.  
  1409.  
  1410. (***************************************************************************
  1411. **
  1412. ** Scrollbar-Object
  1413. ** -------------
  1414. **
  1415. ***************************************************************************)
  1416.  
  1417.   PROCEDURE Scrollbar * {"MuiBasics.ScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1418.   PROCEDURE scrollbar * {"MuiBasics.ScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1419.   PROCEDURE ScrollbarA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1420.     BEGIN
  1421.       ScrollbarObject( m.aSliderMin, min,
  1422.                       m.aSliderMax, max,
  1423.                       m.aSliderLevel, level,
  1424.                       m.aGroupHoriz, e.true,
  1425.                       u.end );
  1426.         TagsA( tags );
  1427.       RETURN End();
  1428.     END ScrollbarA;
  1429.  
  1430.   PROCEDURE KeyScrollbar * {"MuiBasics.KeyScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1431.   PROCEDURE keyScrollbar * {"MuiBasics.KeyScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1432.   PROCEDURE KeyScrollbarA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1433.     BEGIN
  1434.         y.INLINE( 0285H, 0000H, 00FFH );  (* andi.l  #000000FF,d5 *)
  1435.       RETURN  Scrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  1436.     END KeyScrollbarA;
  1437.  
  1438.   PROCEDURE VScrollbar * {"MuiBasics.VScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1439.   PROCEDURE vScrollbar * {"MuiBasics.VScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; tags{9}.. : u.Tag );
  1440.   PROCEDURE VScrollbarA * ( min{2}, max{3}, level{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1441.     BEGIN
  1442.       ScrollbarObject(m.aSliderMin, min,
  1443.                     m.aSliderMax, max,
  1444.                     m.aSliderLevel, level,
  1445.                     u.end );
  1446.         TagsA( tags );
  1447.       RETURN End();
  1448.     END VScrollbarA;
  1449.  
  1450.   PROCEDURE KeyVScrollbar * {"MuiBasics.KeyVScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag ):m.Object;
  1451.   PROCEDURE keyVScrollbar * {"MuiBasics.KeyVScrollbarA"} ( min{2}, max{3}, level{4} : LONGINT; key{5} : CHAR; tags{9}.. : u.Tag );
  1452.   PROCEDURE KeyVScrollbarA * ( min{2}, max{3}, level{4}, key{5} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1453.     BEGIN
  1454.         y.INLINE( 0285H, 0000H, 00FFH );  (* andi.l  #000000FF,d5 *)
  1455.       RETURN  VScrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  1456.       (* RETURN End(); *)       (* Was sollte das denn ? *)
  1457.     END KeyVScrollbarA;
  1458.  
  1459.  
  1460. (***************************************************************************
  1461. **
  1462. ** Button to be used for popup objects
  1463. **
  1464. ***************************************************************************)
  1465.  
  1466.   PROCEDURE PopButton* {"MuiBasics.PopButtonA"} ( img{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  1467.   PROCEDURE popButton* {"MuiBasics.PopButtonA"} ( img{3} : LONGINT; tags{9}.. : u.Tag );
  1468.   PROCEDURE PopButtonA*( img{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  1469.     BEGIN
  1470.       ImageObject;
  1471.         ImageButtonFrame( m.aImageSpec, img,
  1472.                           m.aImageFontMatchWidth, e.true,
  1473.                           m.aImageFreeVert, e.true,
  1474.                           m.aInputMode, m.vInputModeRelVerify,
  1475.                           m.aBackground, m.iBACKGROUND,
  1476.                           u.end );
  1477.         TagsA( tags );
  1478.       RETURN End();
  1479.     END PopButtonA;
  1480.  
  1481.  
  1482. (***************************************************************************
  1483. **
  1484. ** Popup-Object
  1485. ** ------------
  1486. **
  1487. ** An often needed GUI element is a string gadget with a little button
  1488. ** that opens up a (small) window with a list containing possible entries
  1489. ** for this gadget. Together with the Popup and the String macro,
  1490. ** such a thing would look like
  1491. **
  1492. ** VGroup;
  1493. **    Child; PopupBegin;
  1494. **             Child; STFont := String( "helvetica/13", 32 );
  1495. **           PopupEnd( hook, m.iPopUp, STFont );
  1496. **    ...;
  1497. **
  1498. ** STFont will hold a pointer to the embedded string gadget and can
  1499. ** be used to set and get its contents as with every other string object.
  1500. **
  1501. ** For Hook description see below.
  1502. ** The hook will be called with the string gadget as object whenever
  1503. ** the user releases the popup button and could look like this:
  1504. **
  1505. ** PROCEDURE FontReq( hook : Hook; obj : m.Object : args : Args) : LONGINT;
  1506. **   VAR window : I.WindowPtr;
  1507. **       l, t, w, h : LONGINT;
  1508. **       req : ASL.AslRequesterPtr;
  1509. ** BEGIN
  1510. **    ...
  1511. **
  1512. **    (* put our application to sleep while displaying the requester *)
  1513. **      Set( Application, m.aApplicationSleep, e.true );
  1514. **
  1515. **    (* get the calling objects window and position *)
  1516. **      Get( obj, m.aWindow  , window );
  1517. **      Get( obj, m.aLeftEdge, l );
  1518. **      Get( obj, m.aTopEdge , t );
  1519. **      Get( obj, m.aWidth   , w );
  1520. **      Get( obj, m.aHeight  , h );
  1521. **
  1522. **    req := m.AllocAslRequestTags( ASL.fontRequest, u.done )
  1523. **    IF req # NIL THEN
  1524. **
  1525. **       IF (m.AslRequestTags(req,
  1526. **               ASL.foWindow         ,window,
  1527. **               ASL.foPrivateIDCMP   ,TRUE,
  1528. **               ASL.foTitleText      ,"Select Font",
  1529. **               ASL.foInitialLeftEdge,window->LeftEdge + l,
  1530. **               ASL.foInitialTopEdge ,window->TopEdge  + t+h,
  1531. **               ASL.foInitialWidth   ,w,
  1532. **               ASL.foInitialHeight  ,250,
  1533. **               u.done ) ) THEN
  1534. **
  1535. **          (* set the new contents for our string gadget *)
  1536. **                              Set( args(PopupArgs).linkedObj, m.aStringContents, req(ASL.FontRequester).attr.name);
  1537. **       END;
  1538. **       m.FreeAslRequest( req );
  1539. **   END;
  1540. **
  1541. **    (* wake up our application again *)
  1542. **      Set(Application, m.aApplicationSleep, e.false );
  1543. **
  1544. **      RETURN( 0);
  1545. ** END FontReq:
  1546. **
  1547. ** Note: This Procedure is translated to Oberon on the fly, no warranty is given
  1548. **       that this piece of code works.
  1549. **
  1550. ***************************************************************************)
  1551.  
  1552.   PROCEDURE PopupBegin * ();
  1553.     VAR dummy : m.Object;
  1554.     BEGIN
  1555.       HGroup; GroupSpacing( 1 );
  1556.     END PopupBegin;
  1557.  
  1558.   PROCEDURE popupEnd * {"MuiBasics.PopupEnd"} ( hook : Hook; img : LONGINT; obj : m.Object );
  1559.   PROCEDURE PopupEnd * ( hook : Hook; img : LONGINT; obj : m.Object ):m.Object;
  1560.     VAR dummy : m.Object;
  1561.     BEGIN
  1562.         Child; ImageObject;
  1563.                  ImageButtonFrame;
  1564.                  Tags( m.aImageSpec, img,
  1565.                        m.aImageFontMatchWidth, e.true,
  1566.                        m.aImageFreeVert, e.true,
  1567.                        m.aInputMode, m.vInputModeRelVerify,
  1568.                        m.aBackground, m.iButtonBack,
  1569.                        u.end );
  1570.                dummy := End();
  1571.                IF (obj # NIL) & (dummy # NIL) & (hook # NIL) THEN
  1572.                  m.DoMethod( dummy, m.mNotify, m.aPressed, e.false,
  1573.                                dummy, 3, m.mCallHook, hook, obj );
  1574.                END;
  1575.       end;
  1576.       RETURN dummy;
  1577.     END PopupEnd;
  1578.  
  1579.  
  1580. (***************************************************************************
  1581. **
  1582. ** Labeling Objects
  1583. ** ----------------
  1584. **
  1585. ** Labeling objects, e.g. a group of string gadgets,
  1586. **
  1587. **   Small: |foo   |
  1588. **  Normal: |bar   |
  1589. **     Big: |foobar|
  1590. **    Huge: |barfoo|
  1591. **
  1592. ** is done using a 2 column group:
  1593. **
  1594. ** ColGroup(2);
  1595. **      Child; Label2( "Small:"  );
  1596. **    Child; StringObject; end;
  1597. **      Child; Label2( "Normal:" );
  1598. **    Child; StringObject; end;
  1599. **      Child; Label2( "Big:"    );
  1600. **    Child; StringObject; end;
  1601. **      Child; Label2( "Huge:"   );
  1602. **    Child; StringObject; end;
  1603. **    end;
  1604. **
  1605. ** Note that we have three versions of the label procedure, depending on
  1606. ** the frame type of the right hand object:
  1607. **
  1608. ** Label1(): For use with standard frames (e.g. checkmarks).
  1609. ** Label2(): For use with double high frames (e.g. string gadgets).
  1610. ** Label() : For use with objects without a frame.
  1611. **
  1612. ** These procedures ensure that your label will look fine even if the
  1613. ** user of your application configured some strange spacing values.
  1614. ** If you want to use your own labeling, you'll have to pay attention
  1615. ** on this topic yourself.
  1616. **
  1617. ***************************************************************************)
  1618.  
  1619.   PROCEDURE Label * ( label : ARRAY OF CHAR ):m.Object;
  1620.   (* $CopyArrays- *)
  1621.     BEGIN
  1622.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1623.                   m.aTextContents, y.ADR( label ),
  1624.                   m.aWeight      , 0,
  1625.                   m.aInnerLeft   , 0,
  1626.                   m.aInnerRight  , 0,
  1627.                   u.end );
  1628.       RETURN End();
  1629.     END Label;
  1630.  
  1631.   PROCEDURE Label1 * ( label : ARRAY OF CHAR ):m.Object;
  1632.   (* $CopyArrays- *)
  1633.     BEGIN
  1634.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1635.                   m.aTextContents, y.ADR( label ),
  1636.                   m.aWeight      , 0,
  1637.                   m.aInnerLeft   , 0,
  1638.                   m.aInnerRight  , 0,
  1639.                   u.end );
  1640.         ButtonFrame;
  1641.           TagItem( m.aFramePhantomHoriz, e.true );
  1642.       RETURN End();
  1643.     END Label1;
  1644.  
  1645.   PROCEDURE Label2 * ( label : ARRAY OF CHAR ):m.Object;
  1646.   (* $CopyArrays- *)
  1647.     BEGIN
  1648.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1649.                   m.aTextContents, y.ADR( label ),
  1650.                   m.aWeight      , 0,
  1651.                   m.aInnerLeft   , 0,
  1652.                   m.aInnerRight  , 0,
  1653.                   u.end );
  1654.         StringFrame;
  1655.          TagItem( m.aFramePhantomHoriz, e.true );
  1656.       RETURN End();
  1657.     END Label2;
  1658.  
  1659.   PROCEDURE LLabel * ( label : ARRAY OF CHAR ):m.Object;
  1660.   (* $CopyArrays- *)
  1661.     BEGIN
  1662.       TextObject( m.aTextContents, y.ADR( label ),
  1663.                   m.aWeight      , 0,
  1664.                   m.aInnerLeft   , 0,
  1665.                   m.aInnerRight  , 0,
  1666.                   u.end );
  1667.       RETURN End();
  1668.     END LLabel;
  1669.  
  1670.   PROCEDURE LLabel1 * ( label : ARRAY OF CHAR ):m.Object;
  1671.   (* $CopyArrays- *)
  1672.     BEGIN
  1673.       TextObject( m.aTextContents, y.ADR( label ),
  1674.                   m.aWeight      , 0,
  1675.                   m.aInnerLeft   , 0,
  1676.                   m.aInnerRight  , 0,
  1677.                   u.end );
  1678.         ButtonFrame;
  1679.           TagItem( m.aFramePhantomHoriz, e.true );
  1680.       RETURN End();
  1681.     END LLabel1;
  1682.  
  1683.   PROCEDURE LLabel2 * ( label : ARRAY OF CHAR ):m.Object;
  1684.   (* $CopyArrays- *)
  1685.     BEGIN
  1686.       TextObject( m.aTextContents, y.ADR( label ),
  1687.                   m.aWeight      , 0,
  1688.                   m.aInnerLeft   , 0,
  1689.                   m.aInnerRight  , 0,
  1690.                   u.end );
  1691.         StringFrame;
  1692.          TagItem( m.aFramePhantomHoriz, e.true );
  1693.       RETURN End();
  1694.     END LLabel2;
  1695.  
  1696.   PROCEDURE KeyLabel * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1697.   (* $CopyArrays- *)
  1698.     BEGIN
  1699.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1700.                   m.aTextContents, y.ADR( label ),
  1701.                   m.aTextHiChar  , ORD( hichar ),
  1702.                   m.aWeight      , 0,
  1703.                   m.aInnerLeft   , 0,
  1704.                   m.aInnerRight  , 0,
  1705.                   u.end );
  1706.       RETURN End();
  1707.     END KeyLabel;
  1708.  
  1709.   PROCEDURE KeyLabel1 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1710.   (* $CopyArrays- *)
  1711.     BEGIN
  1712.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1713.                   m.aTextContents, y.ADR( label ),
  1714.                   m.aTextHiChar  , ORD( hichar ),
  1715.                   m.aWeight      , 0,
  1716.                   m.aInnerLeft   , 0,
  1717.                   m.aInnerRight  , 0,
  1718.                   u.end );
  1719.         ButtonFrame;
  1720.           TagItem( m.aFramePhantomHoriz, e.true );
  1721.       RETURN End();
  1722.     END KeyLabel1;
  1723.  
  1724.   PROCEDURE KeyLabel2 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1725.   (* $CopyArrays- *)
  1726.     BEGIN
  1727.       TextObject( m.aTextPreParse, y.ADR( "\033r" ),
  1728.                   m.aTextContents, y.ADR( label ),
  1729.                   m.aTextHiChar  , ORD( hichar ),
  1730.                   m.aWeight      , 0,
  1731.                   m.aInnerLeft   , 0,
  1732.                   m.aInnerRight  , 0,
  1733.                   u.end );
  1734.         StringFrame;
  1735.           TagItem( m.aFramePhantomHoriz, e.true );
  1736.       RETURN End();
  1737.     END KeyLabel2;
  1738.  
  1739.   PROCEDURE KeyLLabel * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1740.   (* $CopyArrays- *)
  1741.     BEGIN
  1742.       TextObject( m.aTextContents, y.ADR( label ),
  1743.                   m.aTextHiChar  , ORD( hichar ),
  1744.                   m.aWeight      , 0,
  1745.                   m.aInnerLeft   , 0,
  1746.                   m.aInnerRight  , 0,
  1747.                   u.end );
  1748.       RETURN End();
  1749.     END KeyLLabel;
  1750.  
  1751.   PROCEDURE KeyLLabel1 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1752.   (* $CopyArrays- *)
  1753.     BEGIN
  1754.       TextObject( m.aTextContents, y.ADR( label ),
  1755.                   m.aTextHiChar  , ORD( hichar ),
  1756.                   m.aWeight      , 0,
  1757.                   m.aInnerLeft   , 0,
  1758.                   m.aInnerRight  , 0,
  1759.                   u.end );
  1760.         ButtonFrame;
  1761.           TagItem( m.aFramePhantomHoriz, e.true );
  1762.       RETURN End();
  1763.     END KeyLLabel1;
  1764.  
  1765.   PROCEDURE KeyLLabel2 * ( label : ARRAY OF CHAR; hichar : CHAR ):m.Object;
  1766.   (* $CopyArrays- *)
  1767.     BEGIN
  1768.       TextObject( m.aTextContents, y.ADR( label ),
  1769.                   m.aTextHiChar  , ORD( hichar ),
  1770.                   m.aWeight      , 0,
  1771.                   m.aInnerLeft   , 0,
  1772.                   m.aInnerRight  , 0,
  1773.                   u.end );
  1774.         StringFrame;
  1775.           TagItem( m.aFramePhantomHoriz, e.true );
  1776.       RETURN End();
  1777.     END KeyLLabel2;
  1778.  
  1779.   PROCEDURE label * {"MuiBasics.Label"} ( lab : ARRAY OF CHAR );
  1780.  
  1781.   PROCEDURE label1 * {"MuiBasics.Label1"} ( lab : ARRAY OF CHAR );
  1782.  
  1783.   PROCEDURE label2 * {"MuiBasics.Label2"} ( lab : ARRAY OF CHAR );
  1784.  
  1785.   PROCEDURE lLabel * {"MuiBasics.LLabel"} ( lab : ARRAY OF CHAR );
  1786.  
  1787.   PROCEDURE lLabel1 * {"MuiBasics.LLabel1"} ( lab : ARRAY OF CHAR );
  1788.  
  1789.   PROCEDURE lLabel2 * {"MuiBasics.LLabel2"} ( lab : ARRAY OF CHAR );
  1790.  
  1791.   PROCEDURE keyLabel * {"MuiBasics.KeyLabel"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1792.  
  1793.   PROCEDURE keyLabel1 * {"MuiBasics.KeyLabel1"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1794.  
  1795.   PROCEDURE keyLabel2 * {"MuiBasics.KeyLabel2"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1796.  
  1797.   PROCEDURE lKeyLabel * {"MuiBasics.LKeyLabel"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1798.  
  1799.   PROCEDURE lKeyLabel1 * {"MuiBasics.LKeyLabel1"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1800.  
  1801.   PROCEDURE lKeyLabel2 * {"MuiBasics.LKeyLabel2"} ( lab : ARRAY OF CHAR; hichar : CHAR );
  1802.  
  1803. (***************************************************************************
  1804. **
  1805. ** Controlling Objects
  1806. ** -------------------
  1807. **
  1808. ** Set() and Get() are two short stubs for BOOPSI GetAttr() and SetAttrs()
  1809. ** calls:
  1810. **
  1811. **
  1812. **    VAR x : e.STRPTR;
  1813. **
  1814. **    Set(obj,MUIA_String_Contents, y.ADR("foobar") );
  1815. **    Get(obj,MUIA_String_Contents, x);
  1816. **
  1817. **    Dos.PrintF( "gadget contains '%s'\n" , x );
  1818. **
  1819. ** NNset() sets an attribute without triggering a possible notification.
  1820. **
  1821. **
  1822. ***************************************************************************)
  1823.  
  1824.   PROCEDURE Set*( obj : m.Object; attr, value : e.APTR );
  1825.     BEGIN
  1826.       IF I.SetAttrs( obj, attr, value, u.end ) = 0 THEN END
  1827.     END Set;
  1828.  
  1829.   PROCEDURE Get*( obj : m.Object; attr : LONGINT ; VAR store : ARRAY OF e.BYTE );
  1830.     BEGIN
  1831.       IF I.GetAttr( attr, obj, store) = 0 THEN END
  1832.     END Get;
  1833.  
  1834.   PROCEDURE NNSet( obj : m.Object; attr, value : e.APTR );
  1835.     BEGIN
  1836.       IF I.SetAttrs( obj, m.aNoNotify, e.LTRUE, attr, value, u.end ) = 0 THEN END
  1837.     END NNSet;
  1838.  
  1839.   PROCEDURE SetMutex * ( obj : m.Object; n : LONGINT );
  1840.     BEGIN
  1841.       Set( obj, m.aRadioActive, n );
  1842.     END SetMutex;
  1843.  
  1844.   PROCEDURE SetCycle * ( obj : m.Object; n : LONGINT );
  1845.     BEGIN
  1846.       Set( obj, m.aCycleActive, n );
  1847.     END SetCycle;
  1848.  
  1849.   PROCEDURE SetString * ( obj : m.Object; s : e.STRPTR );
  1850.     BEGIN
  1851.       Set( obj, m.aStringContents, s );
  1852.     END SetString;
  1853.  
  1854.   PROCEDURE SetCheckmark * ( obj : m.Object; b : BOOLEAN );
  1855.     BEGIN
  1856.       Set( obj, m.aSelected, y.VAL(SHORTINT,b) );
  1857.     END SetCheckmark;
  1858.  
  1859.   PROCEDURE SetSlider * ( obj : m.Object; l : LONGINT );
  1860.     BEGIN
  1861.       Set( obj, m.aSliderLevel, l );
  1862.     END SetSlider;
  1863.  
  1864.   PROCEDURE PopupObject( args : Args ): m.Object;
  1865.     BEGIN
  1866.       RETURN y.VAL( m.Object, args );
  1867.     END PopupObject;
  1868. BEGIN
  1869.   Init();
  1870. END MuiBasics.
  1871.  
  1872.